package com.xxxx.rpc.service.impl;

import com.xxxx.common.result.RespBean;

import com.xxxx.rpc.pojo.Admin;
import com.xxxx.rpc.pojo.CartList;
import com.xxxx.rpc.pojo.CartVo;
import com.xxxx.rpc.service.CartService;

import com.xxxx.rpc.utils.JsonUtil;
import org.apache.dubbo.config.annotation.Service;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;


import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;


/**
 * 购物车功能的实现类
 */
@Service(interfaceClass = CartService.class)
@Component
public class CartServiceImpl implements CartService {

    //引入Redis
    @Resource
    private RedisTemplate<String,Object> redisTemplate;

    @Value("${user.cart:userCart}")
    private String userCart;


    /**
     * 添加商品到购物车
     * @param cartVo
     * @param admin
     * @return
     */
    @Override
    public RespBean addCart(CartVo cartVo, Admin admin) {
        RespBean respBean = new RespBean();
        if(admin == null || admin.getAdminId() == null){
            respBean.setMessage("用户未登录");
            return respBean;
        }
        //如果用户已经登录，就获取用户的id，在redis中的key就是用户ID
        Short adminId = admin.getAdminId();
        //查出购物车对象信息
        HashOperations<String ,String ,String> hashOperations = redisTemplate.opsForHash();
        Map<String ,String> cartMap = hashOperations.entries( userCart + ":" +adminId);
        //如果购物车信息不为空，就修改购物车中的数量
        if(!CollectionUtils.isEmpty(cartMap)){
            //购物车不为空时，就根据已经存在的商品id获取到商品信息
            String cartStr = cartMap.get(String.valueOf(cartVo.getGoodsId()));
            //商品存在，就只是修改
            if(!StringUtils.isEmpty(cartStr)){
                CartVo vo = JsonUtil.jsonStr2Object(cartStr, CartVo.class);
                //获取商品的数量，之前的数量+新增的数量
                vo.setGoodsNum(vo.getGoodsNum() + cartVo.getGoodsNum());
                //获取实时价格
                vo.setGoodsPrice(cartVo.getGoodsPrice());
                //对redis中value进行添加，这个添加本质是去覆盖掉之前的数据
                cartMap.put(String.valueOf(vo.getGoodsId()) , JsonUtil.object2JsonStr(vo));
            }else {
                //如果不存在，就直接新增
                cartMap.put(String.valueOf(cartVo.getGoodsId()), JsonUtil.object2JsonStr(cartVo));
            }
        }else{
            //如果为空。就直接添加购物车商品
            cartMap = new HashMap<>();
            cartMap.put(String.valueOf(cartVo.getGoodsId()) , JsonUtil.object2JsonStr(cartVo));
        }
        //redis中存储的是key 和value的键值对，在购物车中key是用户id，value是一个map的商品集合，这个map中的key是商品Id，value是商品信息对象
        hashOperations.putAll(  userCart +":"+ adminId , cartMap);
        return respBean;
    }

    /**
     * 获取购物车的数量
     * @param admin
     * @return
     */
    @Override
    public Integer getCartNum(Admin admin) {
        Integer num = 0;
        if(admin == null || admin.getAdminId() == null){
            //判断未登录的时候默认是0
            return 0;
        }
        //如果用户已经登录，就获取用户的id，在redis中的key就是用户ID
        Short adminId = admin.getAdminId();
        //查出购物车对象信息
        HashOperations<String ,String ,String> hashOperations = redisTemplate.opsForHash();
        Map<String ,String> cartMap = hashOperations.entries( userCart + ":" +adminId);
        //如果购物车信息不为空，就修改购物车中的数量
        if(!CollectionUtils.isEmpty(cartMap)) {
            //获取购物车中商品的数量
            for (Map.Entry<String, String> mapEntry : cartMap.entrySet()) {
                CartVo cartVo = JsonUtil.jsonStr2Object(mapEntry.getValue(), CartVo.class);
                num += cartVo.getGoodsNum();
            }
        }
        System.out.println("购物车的数量：" + num);
        return num;
    }
  
    /**
     *  获取购物车列表信息
     * @param admin
     * @return
     */
    @Override
    public CartList getCartAllList(Admin admin) {
        //判断用户不存在
        if(admin == null || admin.getAdminId() == null){
            return null;
        }
        //用户存在，首先进行初始化，默认是null,初始化返回对象
        CartList cartList = null;
        //从redis获取购物车信息
        HashOperations<String , String ,String > hashOperations = redisTemplate.opsForHash();
        Map<String, String> cartMap = hashOperations.entries(userCart + ":" + admin.getAdminId());
        //判断已登录的用户是否存在购物车数据对象
        if(!CollectionUtils.isEmpty(cartMap)){
            //如果存在
            cartList = new CartList();
            //获取到购物车列表信息
            List<CartVo> collect = cartMap.values().stream().map(e -> JsonUtil.jsonStr2Object(e, CartVo.class))
                    .collect(Collectors.toList());
            //总金额
            BigDecimal totalPrices = collect.stream().map(e -> e.getGoodsPrice().multiply(new BigDecimal(String
                    .valueOf(e.getGoodsNum())))).reduce(BigDecimal.ZERO, BigDecimal::add);
            //保留位数
            totalPrices.setScale(2, BigDecimal.ROUND_HALF_UP);
            cartList.setCartVoList(collect);
            cartList.setTotalPrice(totalPrices);
        }
        return cartList;
    }


    /**
     * 清空购物车
     * @param admin
     * @return
     */
    @Override
    public RespBean removeCartAll(Admin admin) {
        RespBean respBean = new RespBean();
        //不考虑用户不登录的情况，进入购物车页面，说明用户已经登录
        //若用户已登录，根据用户id获取到购物车列表，清除,存放在CartList中，直接removeAll()移除，进行清除，返回的结果信息。
        Short adminId = admin.getAdminId();
        CartList cartList = null;
        //获取redis缓存中 的数据
        HashOperations<String , String , String> hashOperations = redisTemplate.opsForHash();
        //根据redis中的key （用户id）得到 redis中的value（商品对象）
        Map<String, String> cartMap = hashOperations.entries(userCart + ":" + adminId);
        //判断用户的购物车对象是否是空的，不是空的则清空，若是空的，不做操作
        if(!CollectionUtils.isEmpty(cartMap)){
            //购物车不为空时，就根据已经存在的商品id获取到商品信息
            for (Map.Entry<String, String> mapEntry : cartMap.entrySet()) {
                //获取到购物车在Redis中的value信息，这是map中的value值
                System.out.println(mapEntry.getValue());
                //这是map中的key值
                System.out.println(mapEntry.getKey());
                //清空购物车
                hashOperations.delete(userCart + ":" + adminId,mapEntry.getKey());
            }
        }
        respBean.setMessage("清空购物车成功！！");
        return respBean;
    }







    /**
     * 添加购物车
     * @param cartVo
     * @param admin
     * @return
     */
    Integer num = 0; //默认购物车的数量
    public RespBean addCart11(CartVo cartVo, Admin admin) {
        RespBean respBean = new RespBean();
        //用户未登录
        if(admin == null){
            respBean.setCode(200);
            respBean.setMessage("用户未登录");
            cartVo.setGoodsNum(num);
            System.out.println("用户未登录，请重新登录");
            return respBean;
        }
        //用户已登录,将单个CartVo对象添加在购物车,可根据商品Id获取购物车信息
      /*  if(admin != null){
            Short adminId = admin.getAdminId();
            //获取当前登录用户的购物车信息
            //List<CartVo> cartVoList = new ArrayList<>();
            if(!StringUtils.isEmpty(cartVo.getGoodsId())){
                //购物车列表为空，直接添加商品到该用户的购物车
                //cartVoList.add(cartVo);
                cartMapper.addCart(cartVo);
                resultInfo.setMsg("添加成功，在购物车等！");
                num += cartVo.getGoodsNum();
            }else{
                //购物车不为空，还要判断添加的商品存不存在，不存在，直接添加，已经存在，修改数量既可
                if(!StringUtils.isEmpty(cartVo)){
                    //商品不存在，直接添加
                    cartMapper.addCart(cartVo);
                    num += cartVo.getGoodsNum();
                }else{
                    //已经存在，修改数量既可
                    CartVo newCartVo = new CartVo();
                    cartVo.setGoodsNum(cartVo.getGoodsNum() + newCartVo.getGoodsNum());
                }
            }
            System.out.println("购物车的数量：" + num);
        }*/
        return respBean;
    }
}
